home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / gnu / gdb / gdb_18s.zoo / main.c < prev    next >
C/C++ Source or Header  |  1992-04-27  |  39KB  |  1,457 lines
  1. /* Top level for GDB, the GNU debugger.
  2.    Copyright (C) 1986, 1987, 1988 Free Software Foundation, Inc.
  3.  
  4. GDB is distributed in the hope that it will be useful, but WITHOUT ANY
  5. WARRANTY.  No author or distributor accepts responsibility to anyone
  6. for the consequences of using it or for whether it serves any
  7. particular purpose or works at all, unless he says so in writing.
  8. Refer to the GDB General Public License for full details.
  9.  
  10. Everyone is granted permission to copy, modify and redistribute GDB,
  11. but only under the conditions described in the GDB General Public
  12. License.  A copy of this license is supposed to have been given to you
  13. along with GDB so you can know your rights and responsibilities.  It
  14. should be in a file named COPYING.  Among other things, the copyright
  15. notice and this notice must be preserved on all copies.
  16.  
  17. In other words, go ahead and share GDB, but don't try to stop
  18. anyone else from sharing it farther.  Help stamp out software hoarding!
  19. */
  20.  
  21. #ifdef atarist
  22. #include <file.h>
  23. #else
  24. #include <sys/file.h>
  25. #endif
  26.  
  27. #include <stdio.h>
  28. #include <setjmp.h>
  29. #include <signal.h>
  30.  
  31. #ifdef atarist
  32. /* #include <param.h> */
  33. #else
  34. #include <sys/param.h>
  35. #endif
  36.  
  37. #include "defs.h"
  38. #include "command.h"
  39. #include "param.h"
  40.  
  41. #ifdef SET_STACK_LIMIT_HUGE
  42. #include <sys/time.h>
  43. #include <sys/resource.h>
  44. #endif
  45.  
  46. /* Version number of GDB, as a string.  */
  47.  
  48. extern char *version;
  49.  
  50. /* Chain containing all defined commands.  */
  51.  
  52. struct cmd_list_element *cmdlist;
  53.  
  54. /* Chain containing all defined info subcommands.  */
  55.  
  56. struct cmd_list_element *infolist;
  57.  
  58. /* stdio stream that command input is being read from.  */
  59.  
  60. FILE *instream;
  61.  
  62. /* Current working directory.  */
  63.  
  64. char *current_directory;
  65.  
  66. /* The directory name is actually stored here (usually).  */
  67. static char dirbuf[MAXPATHLEN];
  68.  
  69. /* Nonzero if we should refrain from using an X window.  */
  70.  
  71. int inhibit_windows = 0;
  72.  
  73. /* Function to call before reading a command, if nonzero.
  74.    The function receives two args: an input stream,
  75.    and a prompt string.  */
  76.    
  77. void (*window_hook) ();
  78.  
  79. extern int frame_file_full_name;
  80.  
  81. void free_command_lines ();
  82. char *read_line ();
  83. static void initialize_main ();
  84. void command_loop ();
  85. static void source_command ();
  86. void print_gdb_version ();
  87.  
  88. #ifdef atarist
  89. static void Save_all_vectors();
  90. static void Restore_all_vectors();
  91. static int atari_logfile;
  92. extern int gcc_mshort;
  93. #endif
  94. void really_exit();
  95.  
  96. /* gdb prints this when reading a command interactively */
  97. static char *prompt;
  98.  
  99. /* Buffer used for reading command lines, and the size
  100.    allocated for it so far.  */
  101.  
  102. char *line;
  103. int linesize;
  104.  
  105. /* This is how `error' returns to command level.  */
  106.  
  107. jmp_buf to_top_level;
  108.  
  109. return_to_top_level ()
  110. {
  111.   quit_flag = 0;
  112.   immediate_quit = 0;
  113.   clear_breakpoint_commands ();
  114.   clear_momentary_breakpoints ();
  115.   delete_current_display ();
  116.   do_cleanups (0);
  117.   longjmp (to_top_level, 1);
  118. }
  119.  
  120. /* Call FUNC with arg ARG, catching any errors.
  121.    If there is no error, return the value returned by FUNC.
  122.    If there is an error, return zero after printing ERRSTRING
  123.     (which is in addition to the specific error message already printed).  */
  124.  
  125. int
  126. catch_errors (func, arg, errstring)
  127.      int (*func) ();
  128.      int arg;
  129.      char *errstring;
  130. {
  131.   jmp_buf saved;
  132.   int val;
  133.  
  134.   bcopy (to_top_level, saved, sizeof (jmp_buf));
  135.  
  136.   if (setjmp (to_top_level) == 0)
  137.     val = (*func) (arg);
  138.   else
  139.     {
  140.       fprintf_filtered (stderr, "%s\n", errstring);
  141.       val = 0;
  142.     }
  143.  
  144.   bcopy (saved, to_top_level, sizeof (jmp_buf));
  145.   return val;
  146. }
  147.  
  148. main (argc, argv, envp)
  149.      int argc;
  150.      char **argv;
  151.      char **envp;
  152. {
  153.   extern void request_quit ();
  154.   int count;
  155.   int inhibit_gdbinit = 0;
  156.   int quiet = 0;
  157.   int batch = 0;
  158.   register int i;
  159.  
  160. #ifdef atarist
  161. #ifndef JRDLIB
  162. #if 0
  163.   extern int _unixmode;
  164.   _unixmode = 0;
  165. #endif
  166.   _binmode(1);
  167. #endif
  168. #endif
  169.  
  170.   quit_flag = 0;
  171.   linesize = 100;
  172.   line = (char *) xmalloc (linesize);
  173.   instream = stdin;
  174.   atari_logfile = 0;
  175.   
  176.   getwd (dirbuf);
  177. #ifdef atarist
  178. #ifndef JRDLIB
  179.   /* adjust for getwd semantic diff */
  180.   if( (dirbuf[3] == '\0') && (dirbuf[1] == ':') &&
  181.       ( 
  182.         (dirbuf[2] == '\\') || (dirbuf[2] == '/')
  183.       )
  184.     )
  185.     dirbuf[2] = '\0';
  186. #endif
  187. #endif
  188.   current_directory = dirbuf;
  189.  
  190. #ifdef SET_STACK_LIMIT_HUGE
  191.   {
  192.     struct rlimit rlim;
  193.  
  194.     /* Set the stack limit huge so that alloca (particularly stringtab
  195.      * in dbxread.c) does not fail. */
  196.     getrlimit (RLIMIT_STACK, &rlim);
  197.     rlim.rlim_cur = rlim.rlim_max;
  198.     setrlimit (RLIMIT_STACK, &rlim);
  199.   }
  200. #endif /* SET_STACK_LIMIT_HUGE */
  201.  
  202.   /* Look for flag arguments.  */
  203.  
  204.   for (i = 1; i < argc; i++)
  205.     {
  206.       if (!strcmp (argv[i], "-q") || !strcmp (argv[i], "-quiet"))
  207.     quiet = 1;
  208.       else if (!strcmp (argv[i], "-nx"))
  209.     inhibit_gdbinit = 1;
  210.       else if (!strcmp (argv[i], "-nw"))
  211.     inhibit_windows = 1;
  212.       else if (!strcmp (argv[i], "-batch"))
  213.     batch = 1, quiet = 1;
  214.       else if (!strcmp (argv[i], "-fullname"))
  215.     frame_file_full_name = 1;
  216. #ifdef atarist
  217.       else if (!strcmp(argv[i], "-D"))
  218.       atari_debug++;
  219.       else if (!strcmp(argv[i], "-mshort"))
  220.       gcc_mshort = 1;
  221.       else if (!strcmp(argv[i], "-L"))
  222.       {
  223.       atari_logfile = 1;
  224.       }
  225. #endif      
  226.       else if (argv[i][0] == '-')
  227.     i++;
  228.     }
  229.  
  230.   /* Run the init function of each source file */
  231.  
  232. #ifdef atarist
  233.   Save_all_vectors();        /* save all exception vectors */
  234. #endif
  235.   initialize_all_files ();
  236.   initialize_main ();        /* But that omits this file!  Do it now */
  237.  
  238.   signal (SIGINT, request_quit);
  239.   signal (SIGQUIT, SIG_IGN);
  240.  
  241.   if (!quiet)
  242.     print_gdb_version ();
  243.  
  244.   /* Process the command line arguments.  */
  245.  
  246.   count = 0;
  247.   for (i = 1; i < argc; i++)
  248.     {
  249.       register char *arg = argv[i];
  250.       /* Args starting with - say what to do with the following arg
  251.      as a filename.  */
  252.       if (arg[0] == '-')
  253.     {
  254.       extern void exec_file_command (), symbol_file_command ();
  255.       extern void core_file_command (), directory_command ();
  256.       extern void tty_command ();
  257.  
  258.       if (!strcmp (arg, "-q") || !strcmp (arg, "-nx")
  259.           || !strcmp (arg, "-quiet") || !strcmp (arg, "-batch")
  260.           || !strcmp (arg, "-fullname")
  261. #ifdef atarist
  262.           || !strcmp (arg, "-D")
  263.           || !strcmp (arg, "-mshort")
  264.           || !strcmp (arg, "-L")
  265. #endif
  266.           )
  267.         /* Already processed above */
  268.         continue;
  269.  
  270.       if (++i == argc)
  271.         fprintf_filtered (stderr, "No argument follows \"%s\".\n", arg);
  272.       if (!setjmp (to_top_level))
  273.         {
  274.           /* -s foo: get syms from foo.  -e foo: execute foo.
  275.          -se foo: do both with foo.  -c foo: use foo as core dump.  */
  276.           if (!strcmp (arg, "-se"))
  277.         {
  278.           exec_file_command (argv[i], !batch);
  279.           symbol_file_command (argv[i], !batch);
  280.         }
  281.           else if (!strcmp (arg, "-s") || !strcmp (arg, "-symbols"))
  282.         symbol_file_command (argv[i], !batch);
  283.           else if (!strcmp (arg, "-e") || !strcmp (arg, "-exec"))
  284.         exec_file_command (argv[i], !batch);
  285.           else if (!strcmp (arg, "-c") || !strcmp (arg, "-core"))
  286.         core_file_command (argv[i], !batch);
  287.           /* -x foo: execute commands from foo.  */
  288.           else if (!strcmp (arg, "-x") || !strcmp (arg, "-command")
  289.                || !strcmp (arg, "-commands"))
  290.         source_command (argv[i]);
  291.           /* -d foo: add directory `foo' to source-file directory
  292.                  search-list */
  293.           else if (!strcmp (arg, "-d") || !strcmp (arg, "-dir")
  294.                || !strcmp (arg, "-directory"))
  295.         directory_command (argv[i], 0);
  296.           /* -cd FOO: specify current directory as FOO.
  297.          GDB remembers the precise string FOO as the dirname.  */
  298.           else if (!strcmp (arg, "-cd"))
  299.         {
  300.           int len = strlen (argv[i]);
  301.           current_directory = argv[i];
  302.           if (len > 1 && current_directory[len - 1] == '/')
  303.             current_directory = savestring (current_directory, len-1);
  304.           chdir (current_directory);
  305.           init_source_path ();
  306.         }
  307.           /* -t /def/ttyp1: use /dev/ttyp1 for inferior I/O.  */
  308.           else if (!strcmp (arg, "-t") || !strcmp (arg, "-tty"))
  309.         tty_command (argv[i], 0);
  310.           else
  311.         error ("Unknown command-line switch: \"%s\"\n", arg);
  312.         }
  313.     }
  314.       else
  315.     {
  316.       /* Args not thus accounted for
  317.          are treated as, first, the symbol/executable file
  318.          and, second, the core dump file.  */
  319.       count++;
  320.       if (!setjmp (to_top_